home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / vibrant / vibprocs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-05  |  35.5 KB  |  789 lines  |  [TEXT/R*ch]
  1. /*   vibprocs.h
  2. * ===========================================================================
  3. *
  4. *                            PUBLIC DOMAIN NOTICE
  5. *            National Center for Biotechnology Information (NCBI)
  6. *
  7. *  This software/database is a "United States Government Work" under the
  8. *  terms of the United States Copyright Act.  It was written as part of
  9. *  the author's official duties as a United States Government employee and
  10. *  thus cannot be copyrighted.  This software/database is freely available
  11. *  to the public for use. The National Library of Medicine and the U.S.
  12. *  Government do not place any restriction on its use or reproduction.
  13. *  We would, however, appreciate having the NCBI and the author cited in
  14. *  any work or product based on this material
  15. *
  16. *  Although all reasonable efforts have been taken to ensure the accuracy
  17. *  and reliability of the software and data, the NLM and the U.S.
  18. *  Government do not and cannot warrant the performance or results that
  19. *  may be obtained by using this software or data. The NLM and the U.S.
  20. *  Government disclaim all warranties, express or implied, including
  21. *  warranties of performance, merchantability or fitness for any particular
  22. *  purpose.
  23. *
  24. * ===========================================================================
  25. *
  26. * File Name:  vibprocs.h
  27. *
  28. * Author:  Jonathan Kans
  29. *
  30. * Version Creation Date:   7/1/91
  31. *
  32. * $Revision: 2.38 $
  33. *
  34. * File Description: 
  35. *       Vibrant procedure definitions
  36. *
  37. * Modifications:  
  38. * --------------------------------------------------------------------------
  39. * Date     Name        Description of modification
  40. * -------  ----------  -----------------------------------------------------
  41. *
  42. *
  43. * ==========================================================================
  44. */
  45.  
  46. #ifndef _VIBPROCS_
  47. #define _VIBPROCS_
  48.  
  49. #ifdef __cplusplus
  50. extern "C" {
  51. #endif
  52.  
  53. /***  GLOBAL VARIABLES  ***/
  54.  
  55. /*
  56. *  The fileDone flag indicates success or failure of the last
  57. *  file operation, and can be used to test for end-of-file on
  58. *  input.  The termCH character contains the character that
  59. *  terminated the most recently read string, field, or line.
  60. *  That character is not included in the string.
  61. */
  62.  
  63. extern  Nlm_Boolean  Nlm_fileDone;
  64. extern  Nlm_Int2     Nlm_fileError;
  65. extern  Nlm_Char     Nlm_termCH;
  66.  
  67. /*
  68. *  The currentKey variable can be used by callback routines to
  69. *  determine what key was most recently pressed by the user.
  70. */
  71.  
  72. extern  Nlm_Char  Nlm_currentKey;
  73.  
  74. /*
  75. *  The cmmdKey, ctrlKey, optKey and shftKey flags reflect the
  76. *  status of the command key, the control key, the option key,
  77. *  and the shift key of the keyboard, respectively.  Macintosh,
  78. *  IBM PC, and Unix machines may only have a subset of these
  79. *  modifier keys on their keyboards.  The dblClick flag is set
  80. *  if the user double clicked in a list selection box.
  81. */
  82.  
  83. extern  Nlm_Boolean  Nlm_cmmdKey;
  84. extern  Nlm_Boolean  Nlm_ctrlKey;
  85. extern  Nlm_Boolean  Nlm_optKey;
  86. extern  Nlm_Boolean  Nlm_shftKey;
  87. extern  Nlm_Boolean  Nlm_dblClick;
  88.  
  89. /*
  90. *  The screenRect contains the size in pixels of the computer screen.
  91. */
  92.  
  93. extern  Nlm_RecT  Nlm_screenRect;
  94.  
  95. /*
  96. *  Miscellaneous constants define the width and height of scroll bars.
  97. */
  98.  
  99. extern  Nlm_Int2  Nlm_hScrollBarHeight;
  100. extern  Nlm_Int2  Nlm_vScrollBarWidth;
  101.  
  102. /*
  103. *  Miscellaneous constants define the height of certain control objects.
  104. */
  105.  
  106. extern  Nlm_Int2  Nlm_popupMenuHeight;
  107. extern  Nlm_Int2  Nlm_dialogTextHeight;
  108.  
  109. /*
  110. *  Copies of argc and argv are available under UNIX for command-line arguments.
  111. */
  112.  
  113. #ifdef WIN_MOTIF
  114. extern int   argc;
  115. extern char  **argv;
  116. #endif
  117.  
  118. /***  PROCEDURES THAT CREATE INTERFACE OBJECTS  ***/
  119.  
  120. /***  WINDOW OBJECTS  ***/
  121.  
  122. /*
  123. *  When positive, the left and top window parameters specify the pixel
  124. *  location of the upper left hand corner of the window on the screen.
  125. *  When negative, they specify the a relative percentage position, with
  126. *  -50, -33 meaning centered horizontally and placed vertically one third
  127. *  of the way down the screen.  When positive, the width and height
  128. *  parameters indicate the pixel size of the window.  When negative, they
  129. *  indicate that the window, when first made visible, will size itself to
  130. *  fit around the objects it contains, with the absolute value of the
  131. *  width being the number of pixels to use as a border around the internal
  132. *  objects and the absolute value of the height being the spacing between
  133. *  objects.
  134. */
  135.  
  136. /*
  137. *  Document, Fixed, and Round windows may be dragged around the screen by
  138. *  the user.  Document windows may also be resized by the user.  When a
  139. *  Modal window is the front window, the user is prevented from bringing
  140. *  other windows to the front or from making menu choices.  This should
  141. *  be used only when extra information is essential in order to proceed,
  142. *  or to alert the user to critical error conditions.  Modal windows should
  143. *  be created when needed and destroyed immediately upon release.  If a
  144. *  modal window is hidden, it may inhibit any user input.  Floating windows
  145. *  float above other windows, and can be useful for selecting tools (such
  146. *  as in a MacPaint drawing palette) without needing to change the active
  147. *  window each time.  The close procedure is called when the user clicks in
  148. *  the close box of a window.  The callback procedure will usually hide or
  149. *  remove the window, or may display a modal window asking the user to
  150. *  confirm the close.  The activate and deactivate procedures are executed
  151. *  when a window is activated or deactivated, and the resize procedure is
  152. *  called when the user changes the size of a window.
  153. */
  154.  
  155. Nlm_WindoW  Nlm_DocumentWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close, Nlm_WndActnProc resize));
  156. Nlm_WindoW  Nlm_FixedWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  157. Nlm_WindoW  Nlm_FrozenWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  158. Nlm_WindoW  Nlm_RoundWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_WndActnProc close));
  159. Nlm_WindoW  Nlm_AlertWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  160. Nlm_WindoW  Nlm_ModalWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  161. Nlm_WindoW  Nlm_FloatingWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  162. Nlm_WindoW  Nlm_ShadowWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  163. Nlm_WindoW  Nlm_PlainWindow PROTO((Nlm_Int2 left, Nlm_Int2 top, Nlm_Int2 width, Nlm_Int2 height, Nlm_WndActnProc close));
  164.  
  165. void        Nlm_SetClose PROTO((Nlm_WindoW w, Nlm_WndActnProc cls));
  166. void        Nlm_SetActivate PROTO((Nlm_WindoW w, Nlm_WndActnProc act));
  167. void        Nlm_SetDeactivate PROTO((Nlm_WindoW w, Nlm_WndActnProc deact));
  168. void        Nlm_SetResize PROTO((Nlm_WindoW w, Nlm_WndActnProc resiz));
  169.  
  170. void        Nlm_SetWindowExtra PROTO((Nlm_WindoW w, Nlm_VoidPtr data, Nlm_WndFreeProc cleanup));
  171. Nlm_VoidPtr Nlm_GetWindowExtra PROTO((Nlm_WindoW w));
  172.  
  173. /***  GROUPING OBJECT  ***/
  174.  
  175. /*
  176. *  Groups are used for fine control of automatic positioning of objects
  177. *  within a window.  When containing radio buttons, the integer value of
  178. *  the group corresponds to the current button choice.  See SetValue and
  179. *  GetValue under Object Title and State Manipulations Procedures.  When
  180. *  both the width and height of a group are 0, objects within the group
  181. *  are overlapped at the same location.  The default group margins are
  182. *  3 horizontal and 2 vertical pixels.  This can be changed with the
  183. *  SetGroupMargins procedure.
  184. */
  185.  
  186. Nlm_GrouP  Nlm_NormalGroup PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_CharPtr title, Nlm_FonT font, Nlm_GrpActnProc actn));
  187. Nlm_GrouP  Nlm_HiddenGroup PROTO((Nlm_GrouP prnt,  Nlm_Int2 width, Nlm_Int2 height, Nlm_GrpActnProc actn));
  188. void       Nlm_SetGroupMargins PROTO((Nlm_GrouP g, Nlm_Int2 xMargin, Nlm_Int2 yMargin));
  189. void       Nlm_SetGroupSpacing PROTO((Nlm_GrouP g, Nlm_Int2 xSpacing, Nlm_Int2 ySpacing));
  190.  
  191. /*
  192. *  In the following object creation procedures, whenever the parent
  193. *  parameter specifies GrouP, a WindoW may also be used, because
  194. *  both objects are handles to the same dummy structure.
  195. */
  196.  
  197. /***  CONTROL OBJECTS  ***/
  198.  
  199. /***  Button Objects  ***/
  200.  
  201. /*
  202. *  Push buttons and Default buttons allow the user to trigger specific
  203. *  callback functions.  Check boxes allow the user to specify boolean
  204. *  yes/no flags.  The parent group containing radio buttons has an
  205. *  integer value that corresponds to one of several mutually exclusive
  206. *  choices that the user can make.  Radio buttons return handles only to
  207. *  allow them to be individually disabled or hidden.  They should be used
  208. *  in the same manner as list items and choice items.
  209. */
  210.  
  211. Nlm_ButtoN  Nlm_PushButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  212. Nlm_ButtoN  Nlm_DefaultButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  213. Nlm_ButtoN  Nlm_CheckBox PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_BtnActnProc actn));
  214. Nlm_ButtoN  Nlm_RadioButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title));
  215.  
  216. /***  Scrolling Choice List Objects  ***/
  217.  
  218. /*
  219. *  Single choice and Multiple choice lists functionally correspond to groups of
  220. *  radio buttons or check boxes.  Because they have the appearance of scrolling
  221. *  choice lists instead of buttons, additional items do not change the size of
  222. *  the list object.  To prevent automatic refreshing of the screen after every
  223. *  append use the Disable function.  Calling Enable will update the list.
  224. */
  225.  
  226. Nlm_LisT  Nlm_SingleList PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_LstActnProc actn));
  227. Nlm_LisT  Nlm_MultiList PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_LstActnProc actn));
  228. void      Nlm_ListItem PROTO((Nlm_LisT l, Nlm_CharPtr title));
  229.  
  230. /***  Menu Objects  ***/
  231.  
  232. /*
  233. *  A Pulldown or Apple menu can appear on the desktop (NULL window) or
  234. *  in a menu bar within a given window.  Popup menus can appear anywhere
  235. *  in a window.  Submenus can appear in any of the above menus, or in
  236. *  other submenus.  Command items act exactly like push buttons, in that
  237. *  they are used to trigger specific callback routines.  Status items
  238. *  correspond to boolean check boxes.  Choice groups are mutually
  239. *  exclusive groups of choices that function exactly like radio groups or
  240. *  single choice lists.  The active choice has a check mark in front of
  241. *  it.  A Popup list is a popup menu with a choice group that displays the
  242. *  current value of the choice group on the window.  The DeskAccGroup
  243. *  allows the user to display a Macintosh desk accessory menu (usually in
  244. *  the Apple menu).  A Font group creates a menu choice group composed of
  245. *  the available fonts in the System file.  The Separator item places a
  246. *  dotted line in between groups of menu items.
  247. */
  248.  
  249. Nlm_MenU    Nlm_PulldownMenu PROTO((Nlm_WindoW w, Nlm_CharPtr title));
  250. Nlm_MenU    Nlm_AppleMenu PROTO((Nlm_WindoW w));
  251. Nlm_MenU    Nlm_PopupMenu PROTO((Nlm_GrouP prnt, Nlm_CharPtr title));
  252. Nlm_MenU    Nlm_SubMenu PROTO((Nlm_MenU m, Nlm_CharPtr title));
  253. Nlm_IteM    Nlm_CommandItem PROTO((Nlm_MenU m, Nlm_CharPtr title, Nlm_ItmActnProc actn));
  254. Nlm_IteM    Nlm_StatusItem PROTO((Nlm_MenU m, Nlm_CharPtr title, Nlm_ItmActnProc actn));
  255. Nlm_ChoicE  Nlm_ChoiceGroup PROTO((Nlm_MenU m, Nlm_ChsActnProc actn));
  256. Nlm_IteM    Nlm_ChoiceItem PROTO((Nlm_ChoicE c, Nlm_CharPtr title));
  257. Nlm_PopuP   Nlm_PopupList PROTO((Nlm_GrouP prnt, Nlm_Boolean macLike, Nlm_PupActnProc actn));
  258. void        Nlm_PopupItem PROTO((Nlm_PopuP p, Nlm_CharPtr title));
  259. void        Nlm_DeskAccGroup PROTO((Nlm_MenU m));
  260. Nlm_ChoicE  Nlm_FontGroup PROTO((Nlm_MenU m));
  261. void        Nlm_SeparatorItem PROTO((Nlm_MenU m));
  262.  
  263. /***  Bar Object  ***/
  264.  
  265. /*
  266. *  This scroll bar is a normal object that can be used for input of integers.
  267. *  Width or height specify the number of standard character widths or standard
  268. *  character line heights to make the scroll bar.  CorrectBarValue will change
  269. *  the scroll bar value without triggering the scroll bar's callback.
  270. */
  271.  
  272. Nlm_BaR  Nlm_ScrollBar PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_BarScrlProc actn));
  273. void     Nlm_CorrectBarValue PROTO((Nlm_BaR b, Nlm_Int2 val));
  274. void     Nlm_CorrectBarMax PROTO((Nlm_BaR b, Nlm_Int2 max));
  275. void     Nlm_CorrectBarPage PROTO((Nlm_BaR b, Nlm_Int2 pgUp, Nlm_Int2 pgDn));
  276.  
  277. /***  Repeat Object  ***/
  278.  
  279. /*
  280. *  Repeat buttons are implemented as autonomous PaneLs.  They will repeatedly
  281. *  trigger the callback in response to click and hold messages.
  282. */
  283.  
  284. Nlm_RepeaT  Nlm_RepeatButton PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_RptClckProc actn));
  285.  
  286. /***  Icon Object  ***/
  287.  
  288. /*
  289. *  Icon buttons are implemented as autonomous PaneLs.  They are used for to display
  290. *  arbitrary bitmaps.  The draw callback should get the value of the icon button to
  291. *  determine what to display.  The click, drag, hold and release mouse callbacks (see
  292. *  SetPanelClick) may set the value of the icon button to change its appearance.
  293. */
  294.  
  295. Nlm_IcoN    Nlm_IconButton PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_IcnActnProc draw, Nlm_IcnChngProc inval,
  296.                 Nlm_IcnClckProc click, Nlm_IcnClckProc drag, Nlm_IcnClckProc hold, Nlm_IcnClckProc release));
  297.  
  298. /***  Switch Object  ***/
  299.  
  300. /*
  301. *  The switch object is used as a miniature scroll bar, with up and down arrows but no
  302. *  thumb or page areas.  It can optionally display a (non-editable) text representation
  303. *  of the value (e.g., "5/15").  The value is manipulated with SetValue and GetValue.
  304. *  The arrows will allow the user to set values from 1 through max.  SetSwitchParams will
  305. *  set both the max and the value at once, to avoid flickering by multiple redraws.
  306. */
  307.  
  308. Nlm_SwitcH  Nlm_UpDownSwitch PROTO((Nlm_GrouP prnt, Nlm_Boolean text, Nlm_SwtChngProc actn));
  309. Nlm_SwitcH  Nlm_LeftRightSwitch PROTO((Nlm_GrouP prnt, Nlm_Boolean text, Nlm_SwtChngProc actn));
  310. void        Nlm_SetSwitchMax PROTO((Nlm_SwitcH s, Nlm_Int2 max));
  311. Nlm_Int2    Nlm_GetSwitchMax PROTO((Nlm_SwitcH s));
  312. void        Nlm_SetSwitchParams PROTO((Nlm_SwitcH s, Nlm_Int2 value, Nlm_Int2 max));
  313.  
  314. /***  TEXT OBJECTS  ***/
  315.  
  316. /***  Editable Text Objects  ***/
  317.  
  318. /*
  319. *  A Dialog text item contains a single line of text, and pressing the
  320. *  tab key will step between individual dialog text items in the front
  321. *  window.  A Scroll text box can hold multiple lines of text.
  322. */
  323.  
  324. Nlm_TexT  Nlm_DialogText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn));
  325. Nlm_TexT  Nlm_HiddenText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn, Nlm_TxtActnProc tabProc));
  326. Nlm_TexT  Nlm_PasswordText PROTO((Nlm_GrouP prnt, Nlm_CharPtr dfault, Nlm_Int2 charWidth, Nlm_TxtActnProc actn));
  327. Nlm_TexT  Nlm_ScrollText PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_FonT font, Nlm_Boolean wrap, Nlm_TxtActnProc actn));
  328.  
  329. void      Nlm_SetTextSelect PROTO((Nlm_TexT t, Nlm_TxtActnProc slct, Nlm_TxtActnProc dslct));
  330.  
  331. Nlm_TexT  Nlm_CurrentText PROTO((void));
  332. void      Nlm_TextSelectionRange PROTO((Nlm_TexT t, Nlm_Int2Ptr begin, Nlm_Int2Ptr end));
  333.  
  334. void      Nlm_CutText PROTO((Nlm_TexT t));
  335. void      Nlm_CopyText PROTO((Nlm_TexT t));
  336. void      Nlm_PasteText PROTO((Nlm_TexT t));
  337. void      Nlm_ClearText PROTO((Nlm_TexT t));
  338.  
  339. Nlm_sizeT    Nlm_TextLength PROTO((Nlm_TexT t));
  340. void      Nlm_SelectText PROTO((Nlm_TexT t, Nlm_Int2 begin, Nlm_Int2 end));
  341.  
  342. /***  Static Prompt Objects  ***/
  343.  
  344. /*
  345. *  The static prompt is not editable, but is used to display status
  346. *  information or instructions to the user.
  347. */
  348.  
  349. Nlm_PrompT  Nlm_StaticPrompt  PROTO((Nlm_GrouP prnt, Nlm_CharPtr title, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_FonT font, Nlm_Char just));
  350.  
  351. /***  Display Object  ***/
  352.  
  353. /*
  354. *  The currently selected display object in the front window receives
  355. *  the output that is sent to the terminal file.
  356. */
  357.  
  358. Nlm_DisplaY  Nlm_NormalDisplay PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  359.  
  360. Nlm_DisplaY  Nlm_ScrollDisplay PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  361.  
  362. /***  SIMPLE UNIVERSAL DRAWING OBJECT  ***/
  363.  
  364. /*
  365. *  A panel object is a rectangular box on a window that provides a universal
  366. *  drawing environment. Panels translate click actions and drawing requests
  367. *  to instance-specific procedures.  The SimplePanel and AutonomousPanel objects
  368. *  are autonomous in that they create a single object within a window or group.
  369. *  (The more general and complex slate/panel combinations are discussed in the
  370. *  next section.)  SetPanelClick assigns click, drag, hold and release callbacks
  371. *  to a given panel.  SimplePanels have only the minimum parameters to specify a
  372. *  panel, and it is expected that the specific application callbacks for click,
  373. *  draw, etc., will handle the entire behavior of the panel.
  374. *
  375. *  AutonomousPanels allow the creation of higher-level graphical objects that
  376. *  can function like built-in Vibrant control objects while allowing much fancier
  377. *  graphical display and manipulation.  The extra parameter specifies the number
  378. *  of extra bytes to be placed on top of the panel instance data, and the data
  379. *  can be accessed with SetPanelExtra and GetPanelExtra.  The reset callback is
  380. *  called via the Reset class function, and should be used to free any instance-
  381. *  specific allocated memory that may be pointed to in the extra data.  In order
  382. *  to override certain class functions (e.g., to allow SetTitle to apply to a
  383. *  particular autonomous panel), the classPtr function can point to a GphPrcs
  384. *  array (in static or heap memory).  Any function pointer that is not NULL will
  385. *  override the standard function.
  386. *
  387. *  The purpose of providing separate slates and panels (see next section) is to
  388. *  allow multiple independent panels to be placed in the same scrolling unit.
  389. *  The slate handles scrolling, and the individual panel children have their
  390. *  own click and draw callbacks.  Slates are distinguished internally from
  391. *  autonomous panels because their click through reset procedures are all NULL.
  392. */
  393.  
  394. Nlm_PaneL  Nlm_SimplePanel PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_PnlActnProc draw));
  395.  
  396. Nlm_PaneL  Nlm_AutonomousPanel PROTO((Nlm_GrouP prnt, Nlm_Int2 pixwidth, Nlm_Int2 pixheight, Nlm_PnlActnProc draw, Nlm_SltScrlProc vscrl, Nlm_SltScrlProc hscrl, Nlm_Int2 extra, Nlm_PnlActnProc reset, Nlm_GphPrcsPtr classPtr));
  397.  
  398. void       Nlm_SetPanelClick PROTO((Nlm_PaneL p, Nlm_PnlClckProc click, Nlm_PnlClckProc drag, Nlm_PnlClckProc hold, Nlm_PnlClckProc release));
  399.  
  400. void       Nlm_SetPanelExtra PROTO((Nlm_PaneL p, Nlm_VoidPtr sptr));
  401. void       Nlm_GetPanelExtra PROTO((Nlm_PaneL p, Nlm_VoidPtr sptr));
  402.  
  403. /***  GENERALIZED SCROLLABLE DRAWING OBJECT  ***/
  404.  
  405. /*
  406. *  A slate object is a rectangular box on a window that provides a universal
  407. *  drawing environment to its panel object children. Panels translate click
  408. *  actions and drawing requests to instance-specific procedures.  The parent
  409. *  slate must be notified of individual row and column pixel offsets, and of
  410. *  the corresponding row heights and column widths, in order for slate scroll
  411. *  bars to work automatically.  The panel must be notified of the actual size
  412. *  of its virtual rectangle.  The panel instance procedures should use the
  413. *  GetOffset procedure to determine the pixel offset for purposes of drawing
  414. *  and responding to clicks.  The VirtualSlate procedure allows specification
  415. *  of virtual scroll positions before and after the real scroll positions in
  416. *  a slate.  When the user drags the scroll bar thumb into a virtual area, the
  417. *  virtual action callback should be used to load new data into the slate.
  418. *  The GeneralSlate allows the specification of an alternative scroll bar
  419. *  callback procedure for a scrolling slate, as well as extra instance space
  420. *  and an overriding class function, in order to effectively have an autonomous
  421. *  scrolling panel.  The default scroll bar procedure should be sufficient
  422. *  for most situations.  Superimposed panels, or derivatives of panels, can be
  423. *  used to build complicated behaviors using simpler objects.
  424. */
  425.  
  426. Nlm_SlatE  Nlm_ScrollSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  427. Nlm_SlatE  Nlm_NormalSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  428. Nlm_SlatE  Nlm_HiddenSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height));
  429. Nlm_SlatE  Nlm_GeneralSlate PROTO((Nlm_GrouP prnt, Nlm_Int2 width, Nlm_Int2 height, Nlm_SltScrlProc scrl, Nlm_Int2 extra, Nlm_GphPrcsPtr classPtr));
  430. void       Nlm_VirtualSlate PROTO((Nlm_SlatE s, Nlm_Int2 before, Nlm_Int2 after, Nlm_SltScrlProc actn));
  431.  
  432. void       Nlm_RegisterRow PROTO((Nlm_SlatE s, Nlm_Int2 position, Nlm_Int2 height, Nlm_Int2 count));
  433. void       Nlm_RegisterColumn PROTO((Nlm_SlatE s, Nlm_Int2 position, Nlm_Int2 width, Nlm_Int2 count));
  434.  
  435. Nlm_BaR    Nlm_GetSlateVScrollBar PROTO((Nlm_SlatE s));
  436. Nlm_BaR    Nlm_GetSlateHScrollBar PROTO((Nlm_SlatE s));
  437.  
  438. Nlm_PaneL  Nlm_CustomPanel PROTO((Nlm_SlatE s, Nlm_PnlActnProc draw, Nlm_Int2 extra, Nlm_PnlActnProc reset));
  439. Nlm_PaneL  Nlm_GeneralPanel PROTO((Nlm_SlatE s, Nlm_PnlActnProc draw, Nlm_Int2 extra, Nlm_PnlActnProc reset, Nlm_GphPrcsPtr classPtr));
  440.  
  441. void       Nlm_RegisterRect PROTO((Nlm_PaneL p, Nlm_RectPtr r));
  442.  
  443. void       Nlm_SetSlateChar PROTO((Nlm_SlatE s, Nlm_SltCharProc chr));
  444. void       Nlm_CaptureSlateFocus  PROTO((Nlm_SlatE s));
  445.  
  446. void       Nlm_SetSlateBorder PROTO((Nlm_SlatE s, Nlm_Boolean turnon));  /* dgg -- let us turn this adornment on/off */
  447.  
  448. /***  APPLICATION CHARACTER PROCEDURE  ***/
  449.  
  450. /*
  451. *  The KeyboardView procedure specifies an application procedure to be
  452. *  called whenever the user presses a key on the keyboard, regardless of
  453. *  other action to be taken in response to that event.
  454. */
  455.  
  456. void  Nlm_KeyboardView PROTO((Nlm_KeyProc key));
  457.  
  458. /***  PRINTING PROCEDURES  ***/
  459.  
  460. Nlm_WindoW   Nlm_StartPrinting PROTO((void));
  461. void         Nlm_EndPrinting PROTO((Nlm_WindoW w));
  462.  
  463. Nlm_Boolean  Nlm_StartPage PROTO((void));
  464. Nlm_Boolean  Nlm_EndPage PROTO((void));
  465.  
  466. Nlm_Boolean  Nlm_PrintingRect PROTO((Nlm_RectPtr rpt));
  467.  
  468. /***  FILE SPECIFICATION PROCEDURES  ***/
  469.  
  470. Nlm_Boolean  Nlm_GetInputFileName PROTO((Nlm_CharPtr fileName, Nlm_sizeT maxsize, Nlm_CharPtr extType, Nlm_CharPtr macType));
  471. Nlm_Boolean  Nlm_GetOutputFileName PROTO((Nlm_CharPtr fileName, Nlm_sizeT maxsize, Nlm_CharPtr dfault));
  472.  
  473. /***  APPLICATION TIMER PROCEDURE  ***/
  474.  
  475. /*
  476. *  The Metronome procedure specifies an application procedure to be called
  477. *  18 or 20 times per second (on the PC and the Macintosh, respectively)
  478. *  regardless of any action by the user.
  479. */
  480.  
  481. void  Nlm_Metronome PROTO((Nlm_VoidProc actn));
  482.  
  483. /***  MAIN EVENT LOOP PROCEDURE  ***/
  484.  
  485. /*
  486. *  After creating all menus, windows, and window objects, the Nlm_Main
  487. *  procedure should call ProcessEvents.  ProcessEvents will convert all
  488. *  toolbox events or messages into calls to the appropriate object.
  489. */
  490.  
  491. void  Nlm_ProcessEvents PROTO((void));
  492.  
  493. /***  QUIT PROGRAM PROCEDURE  ***/
  494.  
  495. /*
  496. *  When a callback function determines that the program is finished it
  497. *  should call QuitProgram.  This will allow the ProcessEvents loop to
  498. *  be exited.
  499. */
  500.  
  501. void  Nlm_QuitProgram PROTO((void));
  502.  
  503. /***  PROCEDURES THAT ATTACH CALLBACKS TO INTERFACE OBJECTS  ***/
  504.  
  505. /*
  506. *  Given a handle to an object, these procedures will set callback
  507. *  functions for various kinds of events.  The action procedure is
  508. *  executed whenever the user does something like clicking the mouse
  509. *  button on an object and then releasing the mouse button while
  510. *  the mouse is still over the object.  The item parameter is 0 to
  511. *  refer to a parent or individual object, and is >0 to refer to a
  512. *  particular child of a group object.  Although only some of the
  513. *  above procedures take an action as an explicit parameter, every
  514. *  graphic object has an action procedure field, which can be set
  515. *  or reset as desired.
  516. */
  517.  
  518. void  Nlm_SetAction PROTO((Nlm_Handle a, Nlm_ActnProc actn));
  519.  
  520. /***  PROCEDURES THAT MODIFY INTERFACE OBJECTS  ***/
  521.  
  522. /***  Object Position and Appearance Procedures  ***/
  523.  
  524. /*
  525. *  When an object is added to a window or group, it is placed at the
  526. *  next available location.  The parent then records the size and
  527. *  position of the object and recalculates the next available location.
  528. *  Advance will place the next object to the right of the previous one
  529. *  (normally it would be placed below the previous object).  Break will
  530. *  place the next object at the left margin underneath all previously
  531. *  defined objects, and will reset the top margin so that Advance will
  532. *  work properly.  SetNextPosition and GetNextPosition give programs
  533. *  finer control over object positioning, including the ability to
  534. *  overlap objects.  Creating a group with width and height equal to 0
  535. *  will also result in overlapped objects.
  536. */
  537.  
  538. void  Nlm_Advance PROTO((Nlm_Handle a));
  539. void  Nlm_Break PROTO((Nlm_Handle a));
  540.  
  541. void  Nlm_SetNextPosition PROTO((Nlm_Handle a, Nlm_PoinT nps));
  542. void  Nlm_GetNextPosition PROTO((Nlm_Handle a, Nlm_PointPtr nps));
  543.  
  544. /***  Item Count Procedure  ***/
  545.  
  546. /*
  547. *  CountItems returns the number of items in a parent object.
  548. */
  549.  
  550. Nlm_Int2  Nlm_CountItems PROTO((Nlm_Handle a));
  551.  
  552. /***  Object Visibility and Responsiveness Procedures  ***/
  553.  
  554. /*
  555. *  Show makes any object visible (unless, for example, the parent of the
  556. *  object happens to be invisible).  All objects except windows are shown
  557. *  when they are created.  Hide will make any object invisible.  Enable
  558. *  and Disable change the responsiveness of an object to mouse clicks and
  559. *  key presses.  All objects are enabled when created.  Select is used to
  560. *  bring windows to the front, to select a dialog text item, or to select
  561. *  a particular display object for use as a console terminal display.
  562. */
  563.  
  564. Nlm_Boolean  Nlm_Enabled PROTO((Nlm_Handle a));
  565. Nlm_Boolean  Nlm_Visible PROTO((Nlm_Handle a));
  566. void         Nlm_ObjectRect PROTO((Nlm_Handle a, Nlm_RectPtr r));
  567. void         Nlm_InvalObject PROTO((Nlm_Handle a));
  568.  
  569. void         Nlm_Show PROTO((Nlm_Handle a));
  570. void         Nlm_Hide PROTO((Nlm_Handle a));
  571. void         Nlm_Enable PROTO((Nlm_Handle a));
  572. void         Nlm_Disable PROTO((Nlm_Handle a));
  573. void         Nlm_Select PROTO((Nlm_Handle a));
  574.  
  575. /***  Object Title and State Manipulation Procedures  ***/
  576.  
  577. /*
  578. *  The status of an object is polled with one of the following procedures.
  579. *  Title refers to the title or prompt of an object.  Three kinds of values
  580. *  are recognized:  Groups of radio buttons, single choice lists, and menu
  581. *  choice groups have elements that are mutually exclusive, and thus have a
  582. *  single integer as their value.  The SetValue and GetValue procedures are
  583. *  appropriate for these objects.  Boolean objects (check boxes, status items)
  584. *  use SetStatus and GetStatus.  GetNextItem will find the first set Boolean
  585. *  item after prev, and will return 0 if there are no more set items.  Text
  586. *  objects use SetTitle and GetTitle.  SetOffset and GetOffset will manipulate
  587. *  the scroll bar offsets for any object.  SetPosition and GetPosition
  588. *  manipulate the position of an object.  SetRange is used to set the page
  589. *  increment and maximum values for a scroll bar.  Reset will clear the value
  590. *  of an object or remove all children from a group.
  591. */
  592.  
  593. void         Nlm_SetTitle PROTO((Nlm_Handle a, Nlm_CharPtr title));
  594. void         Nlm_GetTitle PROTO((Nlm_Handle a, Nlm_CharPtr title, Nlm_sizeT maxsize));
  595. void         Nlm_SetValue PROTO((Nlm_Handle a, Nlm_Int2 value));
  596. Nlm_Int2     Nlm_GetValue PROTO((Nlm_Handle a));
  597. void         Nlm_SetStatus PROTO((Nlm_Handle a, Nlm_Boolean status));
  598. Nlm_Boolean  Nlm_GetStatus PROTO((Nlm_Handle a));
  599. void         Nlm_SetOffset PROTO((Nlm_Handle a, Nlm_Int2 horiz, Nlm_Int2 vert));
  600. void         Nlm_GetOffset PROTO((Nlm_Handle a, Nlm_Int2Ptr horiz, Nlm_Int2Ptr vert));
  601. void         Nlm_SetPosition PROTO((Nlm_Handle a, Nlm_RectPtr r));
  602. void         Nlm_GetPosition PROTO((Nlm_Handle a, Nlm_RectPtr r));
  603. void         Nlm_SetRange PROTO((Nlm_Handle a, Nlm_Int2 pgUp, Nlm_Int2 pgDn, Nlm_Int2 max));
  604.  
  605. void         Nlm_SetItemTitle PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_CharPtr title));
  606. void         Nlm_GetItemTitle PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_CharPtr title, Nlm_sizeT maxsize));
  607. void         Nlm_SetItemStatus PROTO((Nlm_Handle a, Nlm_Int2 item, Nlm_Boolean status));
  608. Nlm_Boolean  Nlm_GetItemStatus PROTO((Nlm_Handle a, Nlm_Int2 item));
  609.  
  610. Nlm_Int2     Nlm_GetNextItem PROTO((Nlm_Handle a, Nlm_Int2 prev));
  611.  
  612. void         Nlm_Reset PROTO((Nlm_Handle a));
  613.  
  614. /***  Object Destruction Procedure  ***/
  615.  
  616. /*
  617. *  Remove hides an object and then completely disposes of all memory structures
  618. *  associated with that object.
  619. */
  620.  
  621. Nlm_Handle  Nlm_Remove PROTO((Nlm_Handle a));
  622.  
  623. /***  MISCELLANEOUS WINDOW AND OBJECT PROCEDURES  ***/
  624.  
  625. Nlm_Handle   Nlm_Parent PROTO((Nlm_Handle a));
  626.  
  627. void         Nlm_RealizeWindow PROTO((Nlm_WindoW w));
  628. Nlm_WindoW   Nlm_WhichWindow PROTO((Nlm_PoinT mouseLoc));
  629. Nlm_Boolean  Nlm_InWindow PROTO((Nlm_PoinT mouseLoc));
  630. Nlm_WindoW   Nlm_FrontWindow PROTO((void));
  631. Nlm_Boolean  Nlm_InFront PROTO((Nlm_WindoW w));
  632. void         Nlm_UseWindow PROTO((Nlm_WindoW w));
  633. Nlm_WindoW   Nlm_CurrentWindow PROTO((void));
  634. Nlm_Boolean  Nlm_UsingWindow PROTO((Nlm_WindoW w));
  635. Nlm_WindoW   Nlm_ActiveWindow PROTO((void));
  636. void         Nlm_EraseWindow PROTO((Nlm_WindoW w));
  637. Nlm_WindoW   Nlm_ParentWindow PROTO((Nlm_Handle a));
  638. Nlm_WindoW   Nlm_SavePort PROTO((Nlm_Handle a));
  639. void         Nlm_RestorePort PROTO((Nlm_WindoW w));
  640. void         Nlm_Update PROTO((void));
  641. Nlm_Boolean  Nlm_EventAvail PROTO((void));
  642. void         Nlm_FlushEvents PROTO((void));
  643. void         Nlm_ProcessAnEvent PROTO((void));
  644. void         Nlm_ProcessEventOrIdle PROTO((void));
  645. void         Nlm_ProcessExternalEvent PROTO((void));
  646. Nlm_Boolean  Nlm_AllParentsEnabled PROTO((Nlm_Handle a));
  647. Nlm_Boolean  Nlm_AllParentsVisible PROTO((Nlm_Handle a));
  648. void         Nlm_RemoveDyingWindows PROTO((void));
  649. void         Nlm_UnloadSegment PROTO((Nlm_VoidProc routineAddr));
  650. Nlm_Boolean  Nlm_LaunchApp PROTO((Nlm_CharPtr fileName));
  651. void         Nlm_SetBarAnomaly PROTO((Nlm_BaR b, Nlm_Boolean anomaly));
  652.  
  653. /***  OBJECT ALIGNMENT PROCEDURE FOR USE WITHOUT GROUP REPOSITIONING  ***/
  654.  
  655. #ifdef WIN_MAC
  656. #define Nlm_HANDLE Nlm_Handle
  657. #endif
  658. #ifdef WIN_MSWIN
  659. #define Nlm_HANDLE int
  660. #endif
  661. #ifdef WIN_MOTIF
  662. #define Nlm_HANDLE Nlm_Handle
  663. #endif
  664.  
  665. #define ALIGN_LEFT      1
  666. #define ALIGN_RIGHT     2
  667. #define ALIGN_CENTER    3
  668. #define ALIGN_JUSTIFY   4
  669. #define ALIGN_UPPER     5
  670. #define ALIGN_LOWER     6
  671. #define ALIGN_MIDDLE    7
  672. #define ALIGN_VERTICAL  8
  673.  
  674. void CDECL   Nlm_AlignObjects VPROTO((int align, ...));
  675.  
  676. /***  FILE HANDLING PROCEDURES  ***/
  677.  
  678. /*
  679. *  Files do not use the same procedures as other kinds of (visual) objects, and
  680. *  have separate procedures for creation, manipulation, and destruction.  The
  681. *  fileDone flag is set if the file was successfully opened.  The fileDone flag
  682. *  also indicates whether a read or write statement was successful, and can be
  683. *  used to determine if the end of a file was detected by a read statement.
  684. */
  685.  
  686. void         Nlm_ReadText PROTO((FILE *f, Nlm_CharPtr str, Nlm_sizeT maxsize));
  687. void CDECL   Nlm_WriteText VPROTO((FILE *f, char *format, ...));
  688. void CDECL   Nlm_WriteLog VPROTO((char *format, ...));
  689.  
  690. Nlm_Char     Nlm_ReadChar PROTO((FILE *f));
  691. void         Nlm_ReadString PROTO((FILE *f, Nlm_CharPtr str, Nlm_sizeT maxsize));
  692. void         Nlm_ReadField PROTO((FILE *f, Nlm_CharPtr str, Nlm_sizeT maxsize));
  693. void         Nlm_ReadLine PROTO((FILE *f, Nlm_CharPtr str, Nlm_sizeT maxsize));
  694. Nlm_Uint2    Nlm_ReadCard PROTO((FILE *f));
  695. Nlm_Int2     Nlm_ReadInt PROTO((FILE *f));
  696. Nlm_Int4     Nlm_ReadLong PROTO((FILE *f));
  697. Nlm_FloatLo  Nlm_ReadReal PROTO((FILE *f));
  698. Nlm_FloatHi  Nlm_ReadDouble PROTO((FILE *f));
  699. void         Nlm_WriteChar PROTO((FILE *f, Nlm_Char ch));
  700. void         Nlm_WriteLn PROTO((FILE *f));
  701. void         Nlm_WriteString PROTO((FILE *f, Nlm_CharPtr str));
  702. void         Nlm_WriteCard PROTO((FILE *f, Nlm_Uint2 cardval, Nlm_Int2 length));
  703. void         Nlm_WriteInt PROTO((FILE *f, Nlm_Int2 intval, Nlm_Int2 length));
  704. void         Nlm_WriteLong PROTO((FILE *f, Nlm_Int4 longval, Nlm_Int2 length));
  705. void         Nlm_WriteReal PROTO((FILE *f, Nlm_FloatLo realval, Nlm_Int2 length, Nlm_Int2 dec));
  706. void         Nlm_WriteDouble PROTO((FILE *f, Nlm_FloatHi doubleval, Nlm_Int2 length, Nlm_Int2 dec));
  707.  
  708. /***  STRING HANDLING PROCEDURES  ***/
  709.  
  710. /*
  711. *  These string functions are intended to be both robust and portable
  712. *  across all operating systems that the NCBI toolbox will support.
  713. *  The maxsize parameter is usually passed sizeof (dest), and will
  714. *  prevent characters from being written past the allocated memory of
  715. *  a string.
  716. */
  717.  
  718. Nlm_Uint4    Nlm_StrngLen PROTO((Nlm_CharPtr string));
  719. void         Nlm_StrngCat PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_sizeT maxsize));
  720. void         Nlm_StrngCpy PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_sizeT maxsize));
  721. Nlm_Boolean  Nlm_StrngPos PROTO((Nlm_CharPtr str, Nlm_CharPtr sub, Nlm_Uint4 start, Nlm_Boolean caseCounts, Nlm_Uint4Ptr match));
  722. void         Nlm_StrngSeg PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_Uint4 start, Nlm_Uint4 length, Nlm_sizeT maxsize));
  723. void         Nlm_StrngRep PROTO((Nlm_CharPtr dest, Nlm_CharPtr source, Nlm_Uint4 start, Nlm_sizeT maxsize));
  724. Nlm_Boolean  Nlm_StrngEql PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  725. Nlm_Int2     Nlm_StrngCmp PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  726. Nlm_Int2     Nlm_SymblCmp PROTO((Nlm_CharPtr str1, Nlm_CharPtr str2, Nlm_Boolean caseCounts));
  727.  
  728. /***  STRING TO NUMBER CONVERSION PROCEDURES  ***/
  729.  
  730. /*
  731. *  The boolean value returned by the String to Number functions indicates
  732. *  whether the conversion was successful (meaning that the string was in
  733. *  fact a legitimate number in the proper range).
  734. */
  735.  
  736. Nlm_Boolean  Nlm_StrToCard PROTO((Nlm_CharPtr str, Nlm_Uint2Ptr cardval));
  737. Nlm_Boolean  Nlm_StrToInt PROTO((Nlm_CharPtr str, Nlm_Int2Ptr intval));
  738. Nlm_Boolean  Nlm_StrToLong PROTO((Nlm_CharPtr str, Nlm_Int4Ptr longval));
  739. Nlm_Boolean  Nlm_StrToPtr PROTO((Nlm_CharPtr str, Nlm_VoidPtr PNTR ptrval));
  740. Nlm_Boolean  Nlm_StrToReal PROTO((Nlm_CharPtr str, Nlm_FloatLoPtr realval));
  741. Nlm_Boolean  Nlm_StrToDouble PROTO((Nlm_CharPtr str, Nlm_FloatHiPtr doubleval));
  742. void         Nlm_CardToStr PROTO((Nlm_Uint2 cardval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_sizeT maxsize));
  743. void         Nlm_IntToStr PROTO((Nlm_Int2 intval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_sizeT maxsize));
  744. void         Nlm_LongToStr PROTO((Nlm_Int4 longval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_sizeT maxsize));
  745. void         Nlm_PtrToStr PROTO((Nlm_VoidPtr ptrval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_sizeT maxsize));
  746. void         Nlm_RealToStr PROTO((Nlm_FloatLo realval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_Int2 dec, Nlm_sizeT maxsize));
  747. void         Nlm_DoubleToStr PROTO((Nlm_FloatHi doubleval, Nlm_CharPtr str, Nlm_Int2 length, Nlm_Int2 dec, Nlm_sizeT maxsize));
  748.  
  749. /***  SPECIALIZED MEMORY ALLOCATION PROCEDURES  ***/
  750.  
  751. /*
  752. *  SetString and GetString are used to conveniently copy C strings to
  753. *  and from relocatable memory allocated on the heap.
  754. */
  755.  
  756. Nlm_Handle  Nlm_SetString PROTO((Nlm_Handle h, Nlm_CharPtr str));
  757. void        Nlm_GetString PROTO((Nlm_Handle h, Nlm_CharPtr str, Nlm_sizeT maxsize));
  758.  
  759. /***  MISCELLANEOUS PROCEDURES  ***/
  760.  
  761. void         Nlm_ArrowCursor PROTO((void));
  762. void         Nlm_CrossCursor PROTO((void));
  763. void         Nlm_IBeamCursor PROTO((void));
  764. void         Nlm_PlusCursor PROTO((void));
  765. void         Nlm_WatchCursor PROTO((void));
  766.  
  767. void         Nlm_Version PROTO((Nlm_CharPtr vsn, Nlm_sizeT maxsize));
  768.  
  769. void         Nlm_MousePosition PROTO((Nlm_PointPtr pt));
  770. Nlm_Boolean  Nlm_MouseButton PROTO((void));
  771. Nlm_Int4     Nlm_ComputerTime PROTO((void));
  772.  
  773. void         Nlm_ProgramPath PROTO((Nlm_CharPtr buf, Nlm_sizeT maxsize));
  774.  
  775. #ifdef WIN_MSWIN
  776. void         Nlm_DisableVibrant PROTO((void));
  777. void         Nlm_EnableVibrant PROTO((void));
  778. #endif /* WIN_MSWIN */
  779.  
  780. /* dgg++ added for use w/ DCLAP c++ library */
  781. void Nlm_SetObject PROTO((Nlm_GraphiC a, Nlm_VoidPtr thisobject));
  782. Nlm_VoidPtr Nlm_GetObject PROTO((Nlm_GraphiC a));
  783.  
  784. #ifdef __cplusplus
  785. }
  786. #endif
  787.  
  788. #endif
  789.